home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / generate / commands.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  13.8 KB  |  406 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import exceptions
  5. import sys
  6. import optparse
  7. import os
  8. import warnings
  9. import traceback
  10. from os.path import isfile, join, split
  11. import ZSI
  12. from ConfigParser import ConfigParser
  13. from ZSI.generate.wsdl2python import WriteServiceModule, ServiceDescription as wsdl2pyServiceDescription
  14. from ZSI.wstools import WSDLTools, XMLSchema
  15. from ZSI.wstools.logging import setBasicLoggerDEBUG
  16. from ZSI.generate import containers, utility
  17. from ZSI.generate.utility import NCName_to_ClassName as NC_to_CN, TextProtect
  18. from ZSI.generate.wsdl2dispatch import ServiceModuleWriter as ServiceDescription
  19. from ZSI.generate.wsdl2dispatch import WSAServiceModuleWriter as ServiceDescriptionWSA
  20. warnings.filterwarnings('ignore', '', exceptions.UserWarning)
  21.  
  22. def SetDebugCallback(option, opt, value, parser, *args, **kwargs):
  23.     setBasicLoggerDEBUG()
  24.     warnings.resetwarnings()
  25.  
  26.  
  27. def SetPyclassMetaclass(option, opt, value, parser, *args, **kwargs):
  28.     ServiceHeaderContainer = ServiceHeaderContainer
  29.     TypecodeContainerBase = TypecodeContainerBase
  30.     TypesHeaderContainer = TypesHeaderContainer
  31.     import ZSI.generate.containers
  32.     TypecodeContainerBase.metaclass = kwargs['metaclass']
  33.     TypesHeaderContainer.imports.append('from %(module)s import %(metaclass)s' % kwargs)
  34.     ServiceHeaderContainer.imports.append('from %(module)s import %(metaclass)s' % kwargs)
  35.  
  36.  
  37. def SetUpLazyEvaluation(option, opt, value, parser, *args, **kwargs):
  38.     TypecodeContainerBase = TypecodeContainerBase
  39.     import ZSI.generate.containers
  40.     TypecodeContainerBase.lazy = True
  41.  
  42.  
  43. def wsdl2py(args = None):
  44.     op = optparse.OptionParser(usage = 'USAGE: %wsdl2py [options] WSDL', description = wsdl2py.__doc__)
  45.     op.add_option('-x', '--schema', action = 'store_true', dest = 'schema', default = False, help = 'process just the schema from an xsd file [no services]')
  46.     op.add_option('-d', '--debug', action = 'callback', callback = SetDebugCallback, help = 'debug output')
  47.     op.add_option('-a', '--address', action = 'store_true', dest = 'address', default = False, help = 'ws-addressing support, must include WS-Addressing schema.')
  48.     op.add_option('-b', '--complexType', action = 'callback', callback = SetPyclassMetaclass, callback_kwargs = {
  49.         'module': 'ZSI.generate.pyclass',
  50.         'metaclass': 'pyclass_type' }, help = 'add convenience functions for complexTypes, including Getters, Setters, factory methods, and properties (via metaclass). *** DONT USE WITH --simple-naming ***')
  51.     op.add_option('-l', '--lazy', action = 'callback', callback = SetUpLazyEvaluation, callback_kwargs = { }, help = 'EXPERIMENTAL: recursion error solution, lazy evalution of typecodes')
  52.     op.add_option('-w', '--twisted', action = 'store_true', dest = 'twisted', default = False, help = 'generate a twisted.web client/server, dependencies python>=2.4, Twisted>=2.0.0, TwistedWeb>=0.5.0')
  53.     op.add_option('-o', '--output-dir', action = 'store', dest = 'output_dir', default = '.', type = 'string', help = 'save files in directory')
  54.     op.add_option('-s', '--simple-naming', action = 'store_true', dest = 'simple_naming', default = False, help = 'map element names directly to python attributes')
  55.     op.add_option('-p', '--pydoc', action = 'store_true', dest = 'pydoc', default = False, help = 'top-level directory for pydoc documentation.')
  56.     is_cmdline = args is None
  57.     if is_cmdline:
  58.         (options, args) = op.parse_args()
  59.     else:
  60.         (options, args) = op.parse_args(args)
  61.     if len(args) != 1:
  62.         print >>sys.stderr, 'Expecting a file/url as argument (WSDL).'
  63.         sys.exit(os.EX_USAGE)
  64.     
  65.     location = args[0]
  66.     if options.schema is True:
  67.         reader = XMLSchema.SchemaReader(base_url = location)
  68.     else:
  69.         reader = WSDLTools.WSDLReader()
  70.     load = reader.loadFromFile
  71.     if not isfile(location):
  72.         load = reader.loadFromURL
  73.     
  74.     
  75.     try:
  76.         wsdl = load(location)
  77.     except Exception:
  78.         e = None
  79.         print >>sys.stderr, 'Error loading %s: \n\t%s' % (location, e)
  80.         traceback.print_exc(sys.stderr)
  81.         if hasattr(os, 'EX_NOINPUT'):
  82.             sys.exit(os.EX_NOINPUT)
  83.         
  84.         sys.exit('error loading %s' % location)
  85.  
  86.     if isinstance(wsdl, XMLSchema.XMLSchema):
  87.         wsdl.location = location
  88.         files = _wsdl2py(options, wsdl)
  89.     else:
  90.         files = _wsdl2py(options, wsdl)
  91.         files.append(_wsdl2dispatch(options, wsdl))
  92.     if getattr(options, 'pydoc', False):
  93.         _writepydoc(os.path.join('docs', 'API'), *files)
  94.     
  95.     if is_cmdline:
  96.         return None
  97.     
  98.     return files
  99.  
  100.  
  101. def _wsdl2py(options, wsdl):
  102.     if options.twisted:
  103.         ServiceHeaderContainer = ServiceHeaderContainer
  104.         import ZSI.generate.containers
  105.         
  106.         try:
  107.             ServiceHeaderContainer.imports.remove('from ZSI import client')
  108.         except ValueError:
  109.             pass
  110.  
  111.         ServiceHeaderContainer.imports.append('from ZSI.twisted import client')
  112.     
  113.     if options.simple_naming:
  114.         containers.SetTypeNameFunc((lambda n: '%s_' % NC_to_CN(n)))
  115.         containers.SetElementNameFunc((lambda n: '%s' % NC_to_CN(n)))
  116.         
  117.         containers.ContainerBase.func_aname = lambda instnc, n: TextProtect(str(n))
  118.         
  119.         utility.namespace_name = lambda cls, ns: utility.Namespace2ModuleName(ns)
  120.     
  121.     files = []
  122.     append = files.append
  123.     if isinstance(wsdl, XMLSchema.XMLSchema):
  124.         wsm = WriteServiceModule(_XMLSchemaAdapter(wsdl.location, wsdl), addressing = options.address)
  125.     else:
  126.         wsm = WriteServiceModule(wsdl, addressing = options.address)
  127.         client_mod = wsm.getClientModuleName()
  128.         client_file = join(options.output_dir, '%s.py' % client_mod)
  129.         append(client_file)
  130.         fd = open(client_file, 'w+')
  131.         wsm.writeClient(fd)
  132.         fd.close()
  133.     types_mod = wsm.getTypesModuleName()
  134.     types_file = join(options.output_dir, '%s.py' % types_mod)
  135.     append(types_file)
  136.     fd = open(types_file, 'w+')
  137.     wsm.writeTypes(fd)
  138.     fd.close()
  139.     return files
  140.  
  141.  
  142. def _wsdl2dispatch(options, wsdl):
  143.     kw = dict()
  144.     if options.twisted:
  145.         WSResource = WSResource
  146.         import ZSI.twisted.WSresource
  147.         kw['base'] = WSResource
  148.         ss = ServiceDescription(**kw)
  149.         if options.address is True:
  150.             raise RuntimeError, 'WS-Address w/twisted currently unsupported, edit the "factory" attribute by hand'
  151.         
  152.     elif options.address is True:
  153.         ss = ServiceDescriptionWSA()
  154.     else:
  155.         ss = ServiceDescription(**kw)
  156.     ss.fromWSDL(wsdl)
  157.     file_name = ss.getServiceModuleName() + '.py'
  158.     fd = open(join(options.output_dir, file_name), 'w+')
  159.     ss.write(fd)
  160.     fd.close()
  161.     return file_name
  162.  
  163.  
  164. class _XMLSchemaAdapter:
  165.     
  166.     def __init__(self, location, schema):
  167.         self.name = '_'.join(split(location)[-1].split('.'))
  168.         self.types = {
  169.             schema.targetNamespace: schema }
  170.  
  171.  
  172. import os
  173. import pydoc
  174. import sys
  175. import warnings
  176. import inspect
  177. import os.path as os
  178. from distutils import log
  179. from distutils.command.build_py import build_py
  180. from distutils.util import convert_path
  181. from ZSI.schema import ElementDeclaration, TypeDefinition
  182.  
  183. def _writedoc(doc, thing, forceload = 0):
  184.     
  185.     try:
  186.         (object, name) = pydoc.resolve(thing, forceload)
  187.         page = pydoc.html.page(pydoc.describe(object), pydoc.html.document(object, name))
  188.         fname = os.path.join(doc, name + '.html')
  189.         file = open(fname, 'w')
  190.         file.write(page)
  191.         file.close()
  192.     except (ImportError, pydoc.ErrorDuringImport):
  193.         value = None
  194.         traceback.print_exc(sys.stderr)
  195.  
  196.     return name + '.html'
  197.  
  198.  
  199. def _writeclientdoc(doc, thing, forceload = 0):
  200.     docmodule = pydoc.HTMLDoc.docmodule
  201.     
  202.     def strongarm(self, object, name = None, mod = (None,), *ignored):
  203.         result = docmodule(self, object, name, mod, *ignored)
  204.         nonmembers = []
  205.         push = nonmembers.append
  206.         for k, v in inspect.getmembers(object, inspect.isclass):
  207.             if inspect.getmodule(v) is not object and getattr(v, 'typecode', None) is not None:
  208.                 push('<a href="%s.html">%s</a>: pyclass alias<br/>' % (v.__name__, k))
  209.                 continue
  210.         
  211.         result += self.bigsection('Aliases', '#ffffff', '#eeaa77', ''.join(nonmembers))
  212.         return result
  213.  
  214.     pydoc.HTMLDoc.docmodule = strongarm
  215.     
  216.     try:
  217.         (object, name) = pydoc.resolve(thing, forceload)
  218.         page = pydoc.html.page(pydoc.describe(object), pydoc.html.document(object, name))
  219.         name = os.path.join(doc, name + '.html')
  220.         file = open(name, 'w')
  221.         file.write(page)
  222.         file.close()
  223.     except (ImportError, pydoc.ErrorDuringImport):
  224.         value = None
  225.         log.debug(str(value))
  226.  
  227.     pydoc.HTMLDoc.docmodule = docmodule
  228.  
  229.  
  230. def _writetypesdoc(doc, thing, forceload = 0):
  231.     
  232.     try:
  233.         (object, name) = pydoc.resolve(thing, forceload)
  234.         name = os.path.join(doc, name + '.html')
  235.     except (ImportError, pydoc.ErrorDuringImport):
  236.         value = None
  237.         log.debug(str(value))
  238.         return None
  239.  
  240.     cdict = { }
  241.     fdict = { }
  242.     elements_dict = { }
  243.     types_dict = { }
  244.     for kname, klass in inspect.getmembers(thing, inspect.isclass):
  245.         if thing is not inspect.getmodule(klass):
  246.             continue
  247.         
  248.         cdict[kname] = inspect.getmembers(klass, inspect.isclass)
  249.         for iname, iklass in cdict[kname]:
  250.             key = (kname, iname)
  251.             fdict[key] = _writedoc(doc, iklass)
  252.             if issubclass(iklass, ElementDeclaration):
  253.                 
  254.                 try:
  255.                     typecode = iklass()
  256.                 except (AttributeError, RuntimeError):
  257.                     ex = None
  258.                     elements_dict[iname] = _writebrokedoc(doc, ex, iname)
  259.                     continue
  260.  
  261.                 elements_dict[iname] = None
  262.                 if typecode.pyclass is not None:
  263.                     elements_dict[iname] = _writedoc(doc, typecode.pyclass)
  264.                     continue
  265.                 continue
  266.             
  267.             if issubclass(iklass, TypeDefinition):
  268.                 
  269.                 try:
  270.                     typecode = iklass(None)
  271.                 except (AttributeError, RuntimeError):
  272.                     ex = None
  273.                     types_dict[iname] = _writebrokedoc(doc, ex, iname)
  274.                     continue
  275.  
  276.                 types_dict[iname] = None
  277.                 if typecode.pyclass is not None:
  278.                     types_dict[iname] = _writedoc(doc, typecode.pyclass)
  279.                     continue
  280.                 continue
  281.                 continue
  282.         
  283.     
  284.     
  285.     def strongarm(self, object, name = None, mod = None, funcs = None, classes = (None, None, None, { }, { }), *ignored):
  286.         realname = object.__name__
  287.         if not name:
  288.             pass
  289.         name = realname
  290.         bases = object.__bases__
  291.         (object, name) = pydoc.resolve(object, forceload)
  292.         contents = []
  293.         push = contents.append
  294.         if name == realname:
  295.             title = '<a name="%s">class <strong>%s</strong></a>' % (name, realname)
  296.         else:
  297.             title = '<strong>%s</strong> = <a name="%s">class %s</a>' % (name, name, realname)
  298.         mdict = { }
  299.         if bases:
  300.             parents = []
  301.             for base in bases:
  302.                 parents.append(self.classlink(base, object.__module__))
  303.             
  304.             title = title + '(%s)' % pydoc.join(parents, ', ')
  305.         
  306.         doc = self.markup(pydoc.getdoc(object), self.preformat, funcs, classes, mdict)
  307.         if doc:
  308.             pass
  309.         doc = '<tt>%s<br> </tt>' % doc
  310.         for iname, iclass in cdict[name]:
  311.             fname = fdict[(name, iname)]
  312.             if elements_dict.has_key(iname):
  313.                 push('class <a href="%s">%s</a>: element declaration typecode<br/>' % (fname, iname))
  314.                 pyclass = elements_dict[iname]
  315.                 if pyclass is not None:
  316.                     push('<ul>instance attributes:')
  317.                     push('<li><a href="%s">pyclass</a>: instances serializable to XML<br/></li>' % elements_dict[iname])
  318.                     push('</ul>')
  319.                 
  320.             pyclass is not None
  321.             if types_dict.has_key(iname):
  322.                 push('class <a href="%s">%s</a>: type definition typecode<br/>' % (fname, iname))
  323.                 pyclass = types_dict[iname]
  324.                 if pyclass is not None:
  325.                     push('<ul>instance attributes:')
  326.                     push('<li><a href="%s">pyclass</a>: instances serializable to XML<br/></li>' % types_dict[iname])
  327.                     push('</ul>')
  328.                 
  329.             pyclass is not None
  330.             push('class <a href="%s">%s</a>: TODO not sure what this is<br/>' % (fname, iname))
  331.         
  332.         contents = ''.join(contents)
  333.         return self.section(title, '#000000', '#ffc8d8', contents, 3, doc)
  334.  
  335.     doclass = pydoc.HTMLDoc.docclass
  336.     pydoc.HTMLDoc.docclass = strongarm
  337.     
  338.     try:
  339.         page = pydoc.html.page(pydoc.describe(object), pydoc.html.document(object, name))
  340.         file = open(name, 'w')
  341.         file.write(page)
  342.         file.close()
  343.     except (ImportError, pydoc.ErrorDuringImport):
  344.         value = None
  345.         log.debug(str(value))
  346.  
  347.     pydoc.HTMLDoc.docclass = doclass
  348.  
  349.  
  350. def _writebrokedoc(doc, ex, name, forceload = 0):
  351.     
  352.     try:
  353.         fname = os.path.join(doc, name + '.html')
  354.         page = pydoc.html.page(pydoc.describe(ex), pydoc.html.document(str(ex), fname))
  355.         file = open(fname, 'w')
  356.         file.write(page)
  357.         file.close()
  358.     except (ImportError, pydoc.ErrorDuringImport):
  359.         value = None
  360.         log.debug(str(value))
  361.  
  362.     return name + '.html'
  363.  
  364.  
  365. def _writepydoc(doc, *args):
  366.     ok = True
  367.     if not os.path.isdir(doc):
  368.         os.makedirs(doc)
  369.     
  370.     if os.path.curdir not in sys.path:
  371.         sys.path.append(os.path.curdir)
  372.     
  373.     for f in args:
  374.         if f.startswith('./'):
  375.             f = f[2:]
  376.         
  377.         name = os.path.sep.join(f.strip('.py').split(os.path.sep))
  378.         
  379.         try:
  380.             e = __import__(name)
  381.         except Exception:
  382.             ex = None
  383.             raise 
  384.  
  385.         if name.endswith('_client'):
  386.             _writeclientdoc(doc, e)
  387.             continue
  388.         
  389.         if name.endswith('_types'):
  390.             _writetypesdoc(doc, e)
  391.             continue
  392.         
  393.         
  394.         try:
  395.             _writedoc(doc, e)
  396.         continue
  397.         except IndexError:
  398.             ex = None
  399.             _writebrokedoc(doc, ex, name)
  400.             continue
  401.             continue
  402.         
  403.  
  404.     
  405.  
  406.